package com.edu.exam.enums.questionbank;

import com.edu.exam.enums.core.BaseEnum;

/**
 * 评分规则类型枚举
 *
 * 管理选择题评分规则的类型，包括全对得分、部分得分、倒扣分、混合评分等类型
 *
 * @author System
 * @version 1.0.0
 */
public enum ScoringRuleType implements BaseEnum {

    /**
     * 全对得分
     */
    FULL_SCORE("FULL_SCORE", "全对得分"),

    /**
     * 部分得分
     */
    PARTIAL_SCORE("PARTIAL_SCORE", "部分得分"),

    /**
     * 倒扣分
     */
    PENALTY("PENALTY", "倒扣分"),

    /**
     * 混合评分
     */
    HYBRID("HYBRID", "混合评分");

    private final String code;
    private final String description;

    ScoringRuleType(String code, String description) {
        this.code = code;
        this.description = description;
    }

    @Override
    public String getCode() {
        return code;
    }

    @Override
    public String getDescription() {
        return description;
    }

    /**
     * 获取枚举的JSON值（使用code）
     *
     * @return 枚举代码
     */
    public String getJsonValue() {
        return code;
    }

    /**
     * 从代码创建枚举实例
     *
     * @param code 枚举代码
     * @return 对应的枚举实例，如果代码无效则返回FULL_SCORE
     */
    public static ScoringRuleType fromCode(String code) {
        if (code == null || code.trim().isEmpty()) {
            return FULL_SCORE;
        }

        for (ScoringRuleType type : values()) {
            if (type.getCode().equals(code)) {
                return type;
            }
        }
        return FULL_SCORE;
    }

    /**
     * 检查是否支持部分得分
     *
     * @return true如果支持部分得分
     */
    public boolean supportsPartialScore() {
        return this == PARTIAL_SCORE || this == HYBRID;
    }

    /**
     * 检查是否支持倒扣分
     *
     * @return true如果支持倒扣分
     */
    public boolean supportsPenalty() {
        return this == PENALTY || this == HYBRID;
    }

    /**
     * 检查是否为严格评分
     *
     * @return true如果是严格评分（全对或零分）
     */
    public boolean isStrictScoring() {
        return this == FULL_SCORE;
    }

    /**
     * 检查是否为宽松评分
     *
     * @return true如果是宽松评分（支持部分得分）
     */
    public boolean isLenientScoring() {
        return this == PARTIAL_SCORE || this == HYBRID;
    }

    /**
     * 检查是否为惩罚性评分
     *
     * @return true如果是惩罚性评分（有倒扣分机制）
     */
    public boolean isPenaltyBased() {
        return this == PENALTY;
    }

    /**
     * 获取评分复杂度等级
     * 数值越大复杂度越高
     *
     * @return 复杂度等级
     */
    public int getComplexityLevel() {
        switch (this) {
            case FULL_SCORE:
                return 1;   // 全对得分最简单
            case PARTIAL_SCORE:
                return 2;   // 部分得分中等
            case PENALTY:
                return 3;   // 倒扣分较复杂
            case HYBRID:
                return 4;   // 混合评分最复杂
            default:
                return 0;
        }
    }

    /**
     * 获取评分公平性等级
     * 数值越大公平性越高
     *
     * @return 公平性等级
     */
    public int getFairnessLevel() {
        switch (this) {
            case PARTIAL_SCORE:
                return 10;  // 部分得分最公平
            case HYBRID:
                return 8;   // 混合评分较公平
            case FULL_SCORE:
                return 6;   // 全对得分中等公平
            case PENALTY:
                return 3;   // 倒扣分公平性较低
            default:
                return 0;
        }
    }

    /**
     * 获取建议的最小选项数量
     *
     * @return 建议的最小选项数量
     */
    public int getMinimumOptionCount() {
        switch (this) {
            case FULL_SCORE:
            case PENALTY:
                return 2;   // 全对得分和倒扣分最少2个选项
            case PARTIAL_SCORE:
                return 3;   // 部分得分至少3个选项
            case HYBRID:
                return 4;   // 混合评分至少4个选项
            default:
                return 2;
        }
    }

    /**
     * 获取评分规则的适用场景
     *
     * @return 适用场景描述
     */
    public String getUseCase() {
        switch (this) {
            case FULL_SCORE:
                return "适用于绝对正确的知识点考察";
            case PARTIAL_SCORE:
                return "适用于部分掌握的知识点考察";
            case PENALTY:
                return "适用于需要减少猜测的考试场景";
            case HYBRID:
                return "适用于复杂知识点的综合考察";
            default:
                return "通用场景";
        }
    }

    /**
     * 获取评分类型的颜色代码
     * 用于UI显示
     *
     * @return 颜色代码
     */
    public String getColorCode() {
        switch (this) {
            case FULL_SCORE:
                return "#28a745";  // 绿色
            case PARTIAL_SCORE:
                return "#17a2b8";  // 蓝色
            case HYBRID:
                return "#ffc107";   // 黄色
            case PENALTY:
                return "#dc3545";    // 红色
            default:
                return "#6c757d";    // 灰色
        }
    }
}